home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / ui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-19  |  16.6 KB  |  673 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  
  5.    Brewster@think.com
  6. */
  7.  
  8. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  9.  
  10.  
  11. #ifndef lint
  12. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-0.2-sf/ir/RCS/ui.c,v 1.3 1994/05/20 12:57:52 pfeifer Exp $";
  13. #endif
  14.  
  15. /* Change log:
  16.  * $Log: ui.c,v $
  17.  * Revision 1.3  1994/05/20  12:57:52  pfeifer
  18.  * beta
  19.  *
  20.  * Revision 1.2  1994/03/08  21:07:06  pfeifer
  21.  * Patchlevel 04
  22.  *
  23.  * Revision 1.1  1993/02/16  15:05:35  freewais
  24.  * Initial revision
  25.  *
  26.  * Revision 1.16  92/03/18  09:01:09  jonathan
  27.  * don't free DocObjs[0]->Type, it's a copy of the input!
  28.  * 
  29.  * Revision 1.15  92/03/06  12:53:03  jonathan
  30.  * Plug another memory leak.  From ericb@baker.dartmouth.edu (Eric J Bivona).
  31.  * 
  32.  * Revision 1.14  92/02/14  15:26:53  jonathan
  33.  * Conditionalized interpret_message and locally_answer_message so client need
  34.  * not include search engine.
  35.  * 
  36.  * Revision 1.13  92/02/12  13:53:41  jonathan
  37.  * Added "$Log" so RCS will put the log message in the header
  38.  * 
  39.  * 
  40. */
  41.  
  42. /* 
  43.  * this is a simple ui toolkit for building other ui's on top.
  44.  * -brewster
  45.  * 
  46.  * top level functions:
  47.  *   generate_search_apdu
  48.  *   generate_retrieval_apdu
  49.  *   interpret_message
  50.  *
  51.  */
  52.  
  53. /* to do:
  54.  *   generate multiple queries for long documents.
  55.  *     this will crash if the file being retrieved is larger than 100k.
  56.  *   
  57.  */
  58.  
  59. #include "ui.h"
  60. #include "wutil.h"
  61. #include "ustubs.h"
  62. #include "futil.h"
  63.  
  64. #include <ctype.h>
  65. #include <errno.h>
  66. /* #include <string.h> */
  67. #include "cdialect.h"
  68. #include <sys/types.h>
  69.  
  70. /* returns a pointer in the buffer of the first free byte.
  71.    if it overflows, then NULL is returned 
  72.  */
  73. char *
  74. generate_search_apdu(buff,
  75.              buff_len,
  76.              seed_words,
  77.              database_name,
  78.              docobjs,
  79.              maxDocsRetrieved)
  80. char* buff;     /* buffer to hold the apdu */
  81. long *buff_len;    /* length of the buffer changed to reflect new data written */
  82. char *seed_words;    /* string of the seed words */
  83. char *database_name;
  84. DocObj** docobjs;
  85. long maxDocsRetrieved;
  86. {
  87.   /* local variables */
  88.  
  89.   SearchAPDU *search3;
  90.   char  *end_ptr;
  91.   static char *database_names[2] = {"", 0};
  92.   any refID;
  93.   WAISSearch *query;
  94.   refID.size = 1;
  95.   refID.bytes = "3";
  96.  
  97.   database_names[0] = database_name;
  98.   query = makeWAISSearch(seed_words,
  99.                          docobjs, /* DocObjsPtr */
  100.                          0L,
  101.                          1L,     /* DateFactor */
  102.                          0L,     /* BeginDateRange */
  103.                          0L,     /* EndDateRange */
  104.                          maxDocsRetrieved
  105.                          );
  106.  
  107.   search3 = makeSearchAPDU(30L, 
  108.                5000L, /* should be large */
  109.                30L,
  110.                            1L,    /* replace indicator */
  111.                            "",    /* result set name */
  112.                            database_names, /* database name */   
  113.                            QT_RelevanceFeedbackQuery, /* query_type */
  114.                            0L,   /* element name */
  115.                            NULL, /* reference ID */
  116.                            query);
  117.  
  118.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  119.  
  120.   CSTFreeWAISSearch(query);
  121.   freeSearchAPDU(search3);
  122.   return(end_ptr);
  123. }
  124.  
  125.  
  126. /* returns a pointer into the buffer of the next free byte.
  127.    if it overflowed, then NULL is returned
  128.  */
  129.  
  130. char *
  131.  generate_retrieval_apdu(buff,
  132.             buff_len,
  133.             docID,
  134.             chunk_type,
  135.             start,
  136.             end,
  137.             type,
  138.             database_name)
  139. char *buff;
  140. long *buff_len;    /* length of the buffer changed to reflect new data written */
  141. any *docID;
  142. long chunk_type;
  143. long start;
  144. long end;
  145. char *type;
  146. char *database_name;
  147. {
  148.   SearchAPDU *search;
  149.   char  *end_ptr;
  150.  
  151.   static char *database_names[2];
  152.   static char *element_names[3];
  153.   any refID;
  154.  
  155.   DocObj *DocObjs[2];
  156.   any *query;            /* changed from char* by brewster */
  157.  
  158.   if(NULL == type)
  159.     type = s_strdup("TEXT");
  160.  
  161.   database_names[0] = database_name;
  162.   database_names[1] = NULL;
  163.  
  164.   element_names[0] = " ";
  165.   element_names[1] = ES_DocumentText;
  166.   element_names[2] = NULL;
  167.  
  168.   refID.size = 1;
  169.   refID.bytes = "3";
  170.   
  171.   switch(chunk_type){
  172.   case CT_line: 
  173.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  174.     break;
  175.   case CT_byte:
  176.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  177.     break;
  178.   }
  179.   DocObjs[1] = NULL;
  180.  
  181.   query = makeWAISTextQuery(DocObjs);   
  182.   search = makeSearchAPDU( 10L, 16L, 15L, 
  183.               1L,    /* replace indicator */
  184.               "FOO", /* result set name */
  185.               database_names, /* database name */   
  186.               QT_TextRetrievalQuery, /* query_type */
  187.               element_names, /* element name */
  188.               &refID, /* reference ID */
  189.               query);
  190.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  191.   /* s_free(DocObjs[0]->Type); it's a copy of the input, don't free it! */
  192.   CSTFreeDocObj(DocObjs[0]);
  193.   CSTFreeWAISTextQuery(query);
  194.   freeSearchAPDU(search);
  195.   return(end_ptr);
  196. }
  197.  
  198. /* not currently used 
  199.  
  200. static boolean isnumber _AP((char* string));
  201.  
  202. static boolean isnumber(string)
  203. char *string;
  204. {
  205.   long count;
  206.   for(count = 0; count < strlen(string); count++){
  207.     if(!isdigit(string[count])){
  208.       return(false);
  209.     }
  210.   }
  211.   return(true);
  212. }
  213.  
  214. */
  215.  
  216. /* this will negotiate with server, and returs the maximum buffer size 
  217.    the server can handle.
  218.  
  219.    A connection should be established first using open_socket.
  220.  
  221. */
  222.  
  223. long init_connection(inBuffer, outBuffer, bufferSize, connection, userInfo)
  224. char *inBuffer, *outBuffer;
  225. long bufferSize;
  226. FILE *connection;
  227. char *userInfo;
  228. { 
  229.   InitAPDU* init = NULL;
  230.   InitResponseAPDU* reply = NULL;
  231.   long result;
  232.   /* construct an init */
  233.   init = makeInitAPDU(true,false,false,false,false,bufferSize,bufferSize,
  234.               userInfo,defaultImplementationID(),
  235.               defaultImplementationName(),
  236.               defaultImplementationVersion(),NULL,userInfo);
  237.   /* write it to the buffer */
  238.   result = writeInitAPDU(init,inBuffer+HEADER_LENGTH,&bufferSize) - inBuffer;
  239.  
  240.   if(result < 0){
  241.     freeInitAPDU(init);
  242.     return(-1);
  243.   }
  244.   if(0 ==
  245.      interpret_message(inBuffer,
  246.                result - HEADER_LENGTH,
  247.                outBuffer,
  248.                bufferSize,
  249.                connection,
  250.                false    /* true verbose */    
  251.                )) {
  252.     /* error making a connection */
  253.     return (-1);
  254.   }
  255.   if (readInitResponseAPDU(&reply,outBuffer + HEADER_LENGTH) == NULL){
  256.     freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  257.     freeInitResponseAPDU(reply);
  258.     return(-1);
  259.   }
  260.   if (reply->Result == false)
  261.     {                /* the server declined service */
  262.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  263.       freeInitResponseAPDU(reply);
  264.       return(-1);
  265.     }
  266.   else                /* we got a response back */
  267.     { result = reply->MaximumRecordSize;
  268.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  269.       freeInitResponseAPDU(reply);
  270.       return(result);
  271.     }
  272. }
  273.  
  274. #ifdef LOCAL_SEARCH
  275. /* returns the length of the response, 0 if an error */
  276. long
  277. locally_answer_message(request_message,
  278.                request_length,
  279.                response_message,
  280.                response_buffer_length)
  281. char *request_message;
  282. long request_length;
  283. char *response_message;
  284. long response_buffer_length;
  285. {
  286.   long request_length_internal = request_length;
  287.   long response_length;
  288.   WAISMessage header;
  289.   long maxBufferSize = response_buffer_length;
  290.  
  291.   readWAISPacketHeader(request_message, &header);
  292.   {
  293.     char length_array[11];
  294.     strncpy(length_array, header.msg_len, 10);
  295.     length_array[10] = '\0';
  296.     request_length_internal = atol(length_array);
  297.   }
  298.   /*
  299.     printf("request length is %ld (%ld from caller)\n", 
  300.     request_length_internal,
  301.     request_length);
  302.     */
  303.   
  304.   response_length =
  305.     interpret_buffer(request_message + HEADER_LENGTH, 
  306.              request_length_internal,
  307.              response_message + HEADER_LENGTH,
  308.              response_buffer_length,
  309.              &maxBufferSize,
  310.              (long)header.hdr_vers,
  311.              NULL);
  312.   if(0 > response_length)
  313.     return(0);
  314.   writeWAISPacketHeader(response_message,
  315.             response_length,
  316.             (long)'z',    /* Z39.50 */
  317.             "DowQuest  ", /* server name */
  318.             (long)NO_COMPRESSION,    /* no compression */
  319.             (long)NO_ENCODING,(long)header.hdr_vers);
  320.   return(response_length);
  321. }
  322. #endif
  323.  
  324. /* this is a safe version of unix 'read' it does all the checking
  325.  * and looping necessary
  326.  * to those trying to modify the transport code to use non-UNIX streams:
  327.  *  This is the function to modify!
  328.  */
  329. long read_from_stream(d,buf,nbytes)
  330. long d;                /* this is the stream */
  331. char *buf;
  332. long nbytes;
  333. {
  334.   long didRead;
  335.   long toRead = nbytes;
  336.   long totalRead = 0;        /* paranoia */
  337.  
  338.   while (toRead > 0){
  339.     didRead = read (d, buf, toRead);
  340.     if(didRead == -1)        /* error*/
  341.       return(-1);
  342.     if(didRead == 0)        /* eof */
  343.       return(-2);        /* maybe this should return 0? */
  344.     toRead -= didRead;
  345.     buf += didRead;
  346.     totalRead += didRead;
  347.   }
  348.   if(totalRead != nbytes)    /* we overread for some reason */
  349.     return(- totalRead);    /* bad news */    
  350.   return(totalRead);
  351. }
  352.  
  353. /* returns the length of the response, 0 if an error */
  354.  
  355. long 
  356. transport_message(connection,
  357.           request_message,
  358.           request_length,
  359.           response_message,
  360.           response_buffer_length)
  361. FILE *connection;
  362. char *request_message;
  363. long request_length;
  364. char *response_message;
  365. long response_buffer_length;
  366. {
  367.   WAISMessage header;
  368.   long response_length;
  369.  
  370.   
  371.   /* Write out message. Read back header. Figure out response length. */
  372.   
  373.   if( request_length + HEADER_LENGTH
  374.      != fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  375.     return 0;
  376.  
  377.   fflush(connection);
  378.  
  379.   /* read for the first '0' */
  380.  
  381.   while(1){
  382.     if(0 > read_from_stream(fileno(connection), response_message, 1))
  383.       return 0;
  384.     if('0' == response_message[0])
  385.       break;
  386.   }
  387.  
  388.   if(0 > read_from_stream(fileno(connection), 
  389.                   response_message + 1, 
  390.                   HEADER_LENGTH - 1))
  391.     return 0;
  392.  
  393.   readWAISPacketHeader(response_message, &header);
  394.   {
  395.     char length_array[11];
  396.     strncpy(length_array, header.msg_len, 10);
  397.     length_array[10] = '\0';
  398.     response_length = atol(length_array);
  399.     /*
  400.       if(verbose){
  401.       printf("WAIS header: '%s' length_array: '%s'\n", 
  402.       response_message, length_array);
  403.       }
  404.       */
  405.     if(response_length > response_buffer_length){
  406.       /* we got a message that is too long, therefore empty the message out,
  407.      and return 0 */
  408.       long i;
  409.       for(i = 0; i < response_length; i++){
  410.     read_from_stream(fileno(connection), 
  411.              response_message + HEADER_LENGTH,
  412.              1);
  413. /*    fread(response_message + HEADER_LENGTH, 1, 1, connection); */
  414.       }
  415.       return(0);
  416.     }
  417.   }
  418.   if(0 > read_from_stream(fileno(connection), 
  419.                   response_message + HEADER_LENGTH,
  420.                   response_length))
  421. /*  if(0 > fread(response_message + HEADER_LENGTH,
  422.            1, response_length, connection)) */
  423.     return 0;
  424.   return(response_length);
  425. }
  426.  
  427.  
  428. /* ------------------------------------------------------------*/
  429.  
  430. /*  Facility to record messages sent and recieved for testing 
  431.     and timing purposes. */
  432.  
  433. /* from c:
  434.  
  435.    putenv(strdup("IR_FILE=/users/menlo-park/brewster/tmp/infile"));
  436.  
  437.    from csh:
  438.  
  439.    setenv IR_FILE /users/menlo-park/brewster/tmp/infile
  440.  
  441.  */
  442.  
  443. boolean environment_variables_read = false; 
  444. char* ir_file_environment_variable = "IR_FILE";
  445. char* ir_file = NULL;
  446.  
  447. void read_environment_variables(host, port)
  448.      char* host;
  449.      char* port;
  450. {
  451.   
  452.   if(!environment_variables_read){
  453.     FILE *stream;
  454.     ir_file = (char*)getenv(ir_file_environment_variable);
  455.     if(ir_file){
  456.       printf("IR_file: %s\n", ir_file);
  457.       stream = fopen(ir_file, "w");
  458.       fprintf(stream, "%s %s\n", host, port);
  459.       fclose(stream);
  460.     }
  461.     environment_variables_read = true;
  462.   }
  463. }
  464.  
  465. /* returns 0 if success */
  466. long write_message_to_file(message, length, filename)
  467.      unsigned char *message;
  468.      long length;
  469.      char*filename;
  470. {
  471.   FILE *stream = fopen(filename, "a");
  472.   if(NULL == stream)
  473.     return(-1);
  474.   
  475.   printf("Writing to file: %s %d characters\n", filename, length);
  476.  
  477.   fprintf(stream, "---------------------------------\n");
  478.   
  479.   if(length != fwrite(message, sizeof(unsigned char), 
  480.               length, stream)){
  481.     perror("fwrite error");
  482.     fclose(stream);
  483.     return(-2);
  484.   }
  485.  
  486.   fprintf(stream, "\n");
  487.  
  488.   if(0 != fclose(stream))
  489.     return(-3);
  490.   return(0);
  491. }  
  492.  
  493. /* ------------------------------------------------------------*/
  494.  
  495. /* returns the number of bytes writeen.  0 if an error */
  496. long
  497. interpret_message(request_message,request_length,
  498.           response_message,
  499.           response_buffer_length,
  500.           connection,
  501.           verbose)
  502. char *request_message;
  503. long request_length; /* length of the buffer */
  504. char *response_message;
  505. long response_buffer_length;
  506. FILE *connection;
  507. boolean verbose;
  508. {
  509.   long response_length;
  510.  
  511.   writeWAISPacketHeader(request_message,
  512.             request_length,
  513.             (long)'z',    /* Z39.50 */
  514.             "wais      ", /* server name */
  515.             (long)NO_COMPRESSION,    /* no compression */
  516.             (long)NO_ENCODING,(long)HEADER_VERSION);
  517.  
  518.   if(ir_file){
  519.     long error_code;
  520.     if(0 != (error_code = 
  521.          write_message_to_file((unsigned char*)request_message, 
  522.                    request_length + HEADER_LENGTH, 
  523.                    ir_file)))
  524.       printf("Error writing log file Code: %d\n", error_code);
  525.   }
  526.     
  527.   if(connection != NULL) {
  528.     if(0 == 
  529.        (response_length =
  530.     transport_message(connection, request_message,
  531.               request_length,
  532.               response_message,
  533.               response_buffer_length)))
  534.       return(0);
  535.   }
  536.   else{
  537. #ifdef LOCAL_SEARCH    
  538.     if(0 == 
  539.        (response_length =
  540.     locally_answer_message(request_message, request_length, 
  541.                    response_message,
  542.                    response_buffer_length)))
  543.       return(0);
  544. #else
  545.     waislog(WLOG_HIGH, WLOG_ERROR, "Local search not supported in this version");
  546.     return(0);
  547. #endif
  548.   }
  549.   if(verbose){
  550.     printf ("decoded %ld bytes: \n", response_length);
  551.     twais_dsply_rsp_apdu(response_message + HEADER_LENGTH, 
  552.              request_length);
  553.   }
  554.   if(ir_file){
  555.     long error_code;
  556.     if(0 != (error_code = 
  557.          write_message_to_file((unsigned char*)response_message, 
  558.                    response_length + HEADER_LENGTH, 
  559.                    ir_file)))
  560.       printf("Error writing log file Code: %d\n", error_code);
  561.   }
  562.   return(response_length);
  563. }
  564.  
  565. /* this closes the connection to the socket.
  566.  * the mythology is that this is cleaner than exiting
  567.  */
  568.  
  569. long close_connection(connection)
  570. FILE *connection;
  571. {
  572.   long result = 0;
  573.   
  574.   if(connection != NULL){
  575.     result = fclose(connection);
  576.   }
  577.   return(result);
  578. }
  579.   
  580. void
  581. display_text_record_completely(record,quote_string_quotes)
  582. WAISDocumentText *record;
  583. boolean quote_string_quotes;
  584. {
  585.   long count;
  586.   /* printf(" Text\n");
  587.      print_any("     DocumentID:  ", record->DocumentID);
  588.      printf("     VersionNumber:  %d\n", record->VersionNumber);
  589.      */
  590.   for(count = 0; count < record->DocumentText->size; count++){
  591.     long ch = (unsigned char)record->DocumentText->bytes[count];
  592.     if(27 == ch){
  593.       /* then we have an escape code */
  594.       /* if the next letter is '(' or ')', then ignore two letters */
  595.       if('(' == record->DocumentText->bytes[count + 1] ||
  596.      ')' == record->DocumentText->bytes[count + 1])
  597.     count += 1;             /* it is a term marker */
  598.       else count += 4;        /* it is a paragraph marker */
  599.     }
  600.     else if (ch == '\t') /* a TAB! */
  601.       putc(ch, stdout);
  602.     else if (isprint(ch)){
  603.       if(quote_string_quotes && ch == '"')
  604.     putc('\\', stdout);
  605.       putc(ch, stdout);
  606.     } 
  607.     else if (ch == '\n' || ch == '\r')
  608.       printf ("\n");
  609.   }
  610. }
  611.  
  612. /* modifies the string to exclude all seeker codes. sets length to
  613.    the new length. */
  614. char *delete_seeker_codes(string,length)
  615. char *string;
  616. long *length;
  617. {
  618.   long original_count; /* index into the original string */
  619.   long new_count = 0; /* index into the collapsed string */
  620.   for(original_count = 0; original_count < *length; original_count++){
  621.     if(27 == string[original_count]){
  622.       /* then we have an escape code */
  623.       /* if the next letter is '(' or ')', then ignore two letters */
  624.       if('(' == string[original_count + 1] ||
  625.     ')' == string[original_count + 1])
  626.      original_count += 1;    /* it is a term marker */
  627.       else original_count += 4; /* it is a paragraph marker */
  628.     }
  629.     else string[new_count++] = string[original_count];
  630.   }
  631.   *length = new_count;
  632.   return(string);
  633. }
  634.  
  635.  
  636.   
  637. /* returns a pointer to a string with good stuff */
  638. char *trim_junk(headline)
  639. char *headline;
  640. {
  641.   long length = strlen(headline) + 1; /* include the trailing null */
  642.   long i,j;
  643.   headline = delete_seeker_codes(headline, &length);
  644.  
  645.  
  646.   /* delete leading spaces */
  647.   for(i=0; i < strlen(headline); i++){
  648.     if(isprint(headline[i])){
  649.       break;
  650.     }
  651.   }
  652.   headline = headline + i;
  653.   /* delete trailing stuff */
  654.   for (i = 0, j = 0; i < strlen(headline)+1; i++) {
  655.     if ((headline[i] != '\r') && (headline[i] != '\n')) {
  656.       headline[j++] = headline[i];
  657.     }
  658.   }
  659.   
  660.  
  661.   for(i=strlen(headline) - 1 ; i > 0; i--){
  662.     if(isprint(headline[i])){
  663.       break;
  664.     }
  665.     headline[i] = '\0';
  666.   }
  667.   
  668.   return(headline);
  669. }
  670.  
  671.  
  672.  
  673.